/**
 * Notes: OA项目对外服务接口
 * Date: 2025-05-01
 * 提供给其他项目调用的标准接口
 */

// 使用统一配置入口引用模型
const { 
  UserModel,
  DepartmentModel,
  FlowModel,
  TaskModel
} = require('../config/models_config.js');
const AppError = require('../../../framework/core/app_error.js');

/**
 * OA项目对外服务类
 */
class CrossService {
  /**
   * 获取用户信息
   * @param {String} userId 用户ID
   * @returns {Promise<Object>} 用户信息DTO
   */
  async getUserInfo(userId) {
    if (!userId) {
      throw new AppError('用户ID不能为空', 10001);
    }

    // 获取用户数据
    const userData = await UserModel.getOne(userId);
    if (!userData) {
      return null;
    }

    // 转换为DTO（仅包含对外共享字段）
    return {
      id: userData._id,
      name: userData.name,
      phone: userData.phone || '',
      avatar: userData.avatar || '',
      status: userData.status,
      department: userData.department,
      position: userData.position || '',
      role: userData.role || []
    };
  }

  /**
   * 获取部门信息
   * @param {String} departmentId 部门ID
   * @returns {Promise<Object>} 部门信息DTO
   */
  async getDepartmentInfo(departmentId) {
    if (!departmentId) {
      throw new AppError('部门ID不能为空', 10002);
    }

    // 获取部门数据
    const departmentData = await DepartmentModel.getOne(departmentId);
    if (!departmentData) {
      return null;
    }

    // 转换为DTO
    return {
      id: departmentData._id,
      name: departmentData.name,
      parentId: departmentData.parentId,
      order: departmentData.order,
      status: departmentData.status,
      leader: departmentData.leader
    };
  }

  /**
   * 获取部门列表
   * @returns {Promise<Array>} 部门列表
   */
  async getDepartmentList() {
    const departmentList = await DepartmentModel.getAll();
    
    // 转换为DTO列表
    return departmentList.map(item => ({
      id: item._id,
      name: item.name,
      parentId: item.parentId,
      order: item.order,
      status: item.status,
      leader: item.leader
    }));
  }

  /**
   * 获取流程定义信息
   * @param {String} flowId 流程ID
   * @returns {Promise<Object>} 流程定义DTO
   */
  async getFlowInfo(flowId) {
    if (!flowId) {
      throw new AppError('流程ID不能为空', 10003);
    }

    // 获取流程数据
    const flowData = await FlowModel.getOne(flowId);
    if (!flowData) {
      return null;
    }

    // 转换为DTO
    return {
      id: flowData._id,
      name: flowData.name,
      type: flowData.type,
      status: flowData.status,
      version: flowData.version,
      steps: flowData.steps,
      forms: flowData.forms,
      applyTo: flowData.applyTo
    };
  }

  /**
   * 创建审批实例
   * @param {Object} approvalData 审批数据
   * @returns {Promise<Object>} 创建结果
   */
  async createApproval(approvalData) {
    if (!approvalData) {
      throw new AppError('审批数据不能为空', 10004);
    }

    // 验证必要字段
    if (!approvalData.flowId) {
      throw new AppError('流程ID不能为空', 10005);
    }

    if (!approvalData.title) {
      throw new AppError('审批标题不能为空', 10006);
    }

    if (!approvalData.applyUser) {
      throw new AppError('申请人ID不能为空', 10007);
    }

    // 验证流程存在
    const flowExists = await FlowModel.exists(approvalData.flowId);
    if (!flowExists) {
      throw new AppError('流程不存在', 10008);
    }

    // 这里调用内部审批流程创建逻辑
    // 实际实现应根据OA项目的具体审批流程
    // 此处仅为示例框架
    const approvalId = ''; // TODO: 调用真实审批创建接口
    
    return {
      id: approvalId,
      success: true,
      message: '审批实例创建成功'
    };
  }

  /**
   * 获取用户列表（分页）
   * @param {Object} params 查询参数
   * @returns {Promise<Object>} 用户列表
   */
  async getUserList(params = {}) {
    const { page = 1, size = 20, department, keyword } = params;

    // 构建查询条件
    const whereCondi = {};
    if (department) {
      whereCondi.department = department;
    }
    if (keyword) {
      whereCondi.name = { $regex: keyword, $options: 'i' };
    }

    const result = await UserModel.getList(whereCondi, page, size);
    
    // 转换为DTO列表
    return {
      total: result.total,
      list: result.list.map(item => ({
        id: item._id,
        name: item.name,
        phone: item.phone || '',
        avatar: item.avatar || '',
        status: item.status,
        department: item.department,
        position: item.position || '',
        role: item.role || []
      }))
    };
  }

  /**
   * 获取流程列表
   * @param {Object} params 查询参数
   * @returns {Promise<Object>} 流程列表
   */
  async getFlowList(params = {}) {
    try {
      const { page = 1, size = 20, status = 'ALL' } = params;
      
      // 构建查询条件
      let whereCondition = {};
      
      // 根据状态过滤
      if (status !== 'ALL') {
        whereCondition.FLOW_STATUS = status;
      }
      
      // 调用模型查询
      const result = await FlowModel.getList(whereCondition, page, size);
      
      // 转换为对外数据格式
      return {
        total: result.total,
        list: result.list.map(item => ({
          id: item._id,
          title: item.FLOW_TITLE || '',
          type: item.FLOW_TYPE || '',
          status: item.FLOW_STATUS || '',
          applyUser: item.FLOW_APPLYUSER || '',
          createTime: item.FLOW_ADD_TIME || ''
        }))
      };
    } catch (err) {
      console.error('[OA跨项目服务] 获取流程列表失败', err);
      throw new AppError('获取流程列表失败:' + err.message, 500);
    }
  }
  
  /**
   * 获取任务列表
   * @param {Object} params 查询参数
   * @returns {Promise<Object>} 任务列表
   */
  async getTaskList(params = {}) {
    try {
      const { page = 1, size = 20, status } = params;
      
      // 构建查询条件
      let whereCondition = {};
      
      // 根据状态过滤
      if (status) {
        whereCondition.TASK_STATUS = status;
      }
      
      // 调用模型查询
      const result = await TaskModel.getList(whereCondition, page, size);
      
      // 转换为对外数据格式
      return {
        total: result.total,
        list: result.list.map(item => ({
          id: item._id,
          title: item.TASK_TITLE || '',
          content: item.TASK_CONTENT || '',
          status: item.TASK_STATUS || '',
          assignUser: item.TASK_ASSIGN_USER || '',
          createTime: item.TASK_ADD_TIME || ''
        }))
      };
    } catch (err) {
      console.error('[OA跨项目服务] 获取任务列表失败', err);
      throw new AppError('获取任务列表失败:' + err.message, 500);
    }
  }
  
  /**
   * 获取OA统计数据
   * @returns {Promise<Object>} 统计数据
   */
  async getStatistics() {
    try {
      // 这里演示直接返回模拟数据
      // 实际项目中应该从数据库中查询真实数据
      return {
        flowCount: 125,
        taskCount: 78,
        userCount: 45,
        completionRate: 76
      };
    } catch (err) {
      console.error('[OA跨项目服务] 获取统计数据失败', err);
      throw new AppError('获取统计数据失败:' + err.message, 500);
    }
  }
  
  /**
   * 关联OA流程与PLM项目
   * @param {String} flowId OA流程ID
   * @param {String} projectId PLM项目ID
   * @returns {Promise<Object>} 关联结果
   */
  async linkFlowToProject(flowId, projectId) {
    try {
      if (!flowId || !projectId) {
        throw new AppError('流程ID和项目ID不能为空', 400);
      }
      
      // 查询流程是否存在
      const flow = await FlowModel.getOne(flowId);
      if (!flow) {
        throw new AppError('流程不存在', 404);
      }
      
      // 更新流程关联的项目ID
      await FlowModel.edit(flowId, {
        FLOW_PROJECT_ID: projectId
      });
      
      return {
        success: true,
        message: '关联成功'
      };
    } catch (err) {
      console.error('[OA跨项目服务] 关联流程与项目失败', err);
      throw new AppError('关联流程与项目失败:' + err.message, 500);
    }
  }
}

module.exports = new CrossService(); 